memcached方式
原理：memcached带有add函数，利用add函数的特性即可实现分布式锁。add和set的区别在于：如果多线程并发set，则每个set都会成功，但最后存储的值以最后的set的线程为准。而add的话则相反，add会添加第一个到达的值，并返回STORED，后续的添加则都会返回NOT_STORED 。利用该点即可很轻松地实现分布式锁。
有点：简单、并发高效。
缺点：（1）memcached采用列入LRU置换策略，所以如果内存不够，可能导致缓存中的锁信息丢失。
（2）memcached无法持久化，一旦重启，将导致信息丢失。
Redis方式
Zookeeper方式
原理：基于zookeeper瞬时有序节点实现的分布式锁，其主要逻辑如下（该图来自于IBM网站）。大致思想即为：每个客户端对某个功能加锁时，在zookeeper上的与该功能对应的指定节点的目录下，生成一个唯一的瞬时有序节点。判断是否获取锁的方式很简单，只需要判断有序节点中序号最小的一个。当释放锁的时候，只需将这个瞬时节点删除即可。同时，其可以避免服务宕机导致的锁无法释放，而产生的死锁问题。
优点：锁安全性高，zk可持久化。
缺点：性能开销比较高。因为其需要动态产生、销毁瞬时节点来实现锁功能。
实现：
可以直接采用zookeeper第三方库curator即可方便地实现分布式锁。以下为基于curator实现的zk分布式锁核心代码：
@Override
public boolean tryLock(LockInfo info) {
InterProcessMutex mutex = getMutex(info);
int tryTimes = info.getTryTimes();
long tryInterval = info.getTryInterval();
boolean flag = true;// 代表是否需要重试
while (flag && --tryTimes >= 0) {
try {
if (mutex.acquire(info.getWaitLockTime(), TimeUnit.MILLISECONDS)) {
LOGGER.info(LogConstant.DST_LOCK + "acquire lock successfully!");
flag = false;
break;
}
} catch (Exception e) {
LOGGER.error(LogConstant.DST_LOCK + "acquire lock error!", e);
} finally {
checkAndRetry(flag, tryInterval, tryTimes);
}
}
return !flag;// 最后还需要重试，说明没拿到锁
}
@Override
public boolean releaseLock(LockInfo info) {
InterProcessMutex mutex = getMutex(info);
int tryTimes = info.getTryTimes();
long tryInterval = info.getTryInterval();
boolean flag = true;// 代表是否需要重试
while (flag && --tryTimes >= 0) {
try {
mutex.release();
LOGGER.info(LogConstant.DST_LOCK + "release lock successfully!");
flag = false;
break;
} catch (Exception e) {
LOGGER.error(LogConstant.DST_LOCK + "release lock error!", e);
} finally {
checkAndRetry(flag, tryInterval, tryTimes);
}
}
return !flag;// 最后还需要重试，说明没拿到锁
}
/**
* 获取锁。此处需要加同步，concurrentHashmap无法避免此处的同步问题
* @param info 锁信息
* @return 锁实例
*/
private synchronized InterProcessMutex getMutex(LockInfo info) {
InterProcessReadWriteLock lock = null;
if (locksCache.get(info.getLock()) != null) {
lock = locksCache.get(info.getLock());
} else {
lock = new InterProcessReadWriteLock(client, BASE_DIR + info.getLock());
locksCache.put(info.getLock(), lock);
}
InterProcessMutex mutex = null;
switch (info.getIsolate()) {
case READ:
mutex = lock.readLock();
break;
case WRITE:
mutex = lock.writeLock();
break;
default:
throw new IllegalArgumentException();
}
return mutex;
}
/**
* 判断是否需要重试
* @param flag 是否需要重试标志
* @param tryInterval 重试间隔
* @param tryTimes 重试次数
*/
private void checkAndRetry(boolean flag, long tryInterval, int tryTimes) {
try {
if (flag) {
Thread.sleep(tryInterval);
LOGGER.info(LogConstant.DST_LOCK + "retry getting lock! now retry time left: " + tryTimes);
}
} catch (InterruptedException e) {
LOGGER.error(LogConstant.DST_LOCK + "retry interval thread interruptted!", e);
}
}
